//
// Created by mi on 2024/5/11.
//

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <array>

/**
 * @brief 演示使用 std::scoped_lock 同时锁定多个互斥量的类
 */
class MultiLockDemo {
public:
    /**
     * @brief 构造函数
     *
     * @param num_threads 要创建的线程数量
     */
    MultiLockDemo(int num_threads) : num_threads_(num_threads) {}

    /**
     * @brief 启动所有线程，并等待它们完成
     */
    void run() {
        for (int i = 0; i < num_threads_; ++i) {
            threads_.emplace_back(&MultiLockDemo::threadWork, this, i);
        }

        for (auto &thread: threads_) {
            thread.join();
        }
    }

private:
    int num_threads_;                           ///< 线程数量
    std::vector<std::thread> threads_;          ///< 线程列表
    std::array<std::mutex, 5> mutexes_;         ///< 互斥量数组

    /**
     * @brief 线程执行的工作
     *
     * @param thread_id 线程的ID
     */
    void threadWork(int thread_id) {
        // 使用 std::scoped_lock 锁定所有互斥量
        std::scoped_lock lock(mutexes_[0], mutexes_[1], mutexes_[2], mutexes_[3], mutexes_[4]);

        // 进行一些工作（示例中为空）
        std::cout << "Thread " << thread_id << " has locked all mutexes." << std::endl;

        // 当函数返回时，std::scoped_lock 的析构函数会自动解锁所有互斥量
    }
};

/**
假如有两个共享资源，scoped_lock 可以做到 同时上锁，解锁。可以有效避免死锁。性能应该不太行。
 */
int main() {
    MultiLockDemo demo(5);
    demo.run();

    return 0;
}